/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package Controle;

import Modelo.Estados;
import Modelo.Tokens;
import java.util.*;

/**
 *
 * @author Heitor
 */
public class Sintatico {
    public static LinkedList<String> sintaqueia(LinkedList<Tokens> tokens){
        
        int counter = 0;
        boolean consumiu = false;
        Stack<Tokens> pilha = new Stack();
        Stack<Estados> estados = new Stack();
        Stack<String> lacos = new Stack();
        int tamanho = tokens.size() - 1;
        Tokens atual = null, lookbehind = null;
        Estados controlador = null;
        Vector oprArit = new Vector();
        Vector oprLog = new Vector();
        LinkedList<String> retorno = new LinkedList();
        
        
        oprArit.add("+");
        oprArit.add("-");
        oprArit.add("*");
        oprArit.add("/");
        oprArit.add("%");
        oprArit.add("^");
        
        oprLog.add("!=");
        oprLog.add("==");
        oprLog.add(">");
        oprLog.add(">=");
        oprLog.add("<");
        oprLog.add("<=");
        oprLog.add("!");
                
        
        
        for(int i=tokens.size()-1;i>=0;i--){
            pilha.push(tokens.get(i));
        }
        
        atual = pilha.pop();
        boolean flag = true;
        if(atual.getLexema().toString().equals("VARIAVEIS")) // primeira entrada if mais externo
        {   
            estados.push(new Estados("<programa>", atual.getLinha()));//estado programa
            lookbehind = atual;
            atual = pilha.pop(); //le o proximo token
            while(estados.peek().getEstado().toString().equals("<programa>"))
            {                
                if(atual.getLexema().toString().equals("{")) // abriu o bloco de declaracoes, estado atual declaraini
                {
                    estados.push(new Estados("<declaraini>", atual.getLinha()));//troca de estado agora XD
                    lookbehind = atual;
                    atual = pilha.pop();
                    while(estados.peek().getEstado().equals("<declaraini>")) 
                    {
                        if(atual.getLexema().toString().equals("}"))
                        {
                            estados.pop();//fechou as declaracoes, volta pra programa
                            lookbehind = atual;
                            atual = pilha.pop();
                        }
                        else
                        {
                            if((atual.getLexema().equals("INTEIRO")) || (atual.getLexema().equals("REAL")) || (atual.getLexema().equals("BOOLEANO")) || (atual.getLexema().equals("STRING")))
                            { 
                                // se leu um tipo, precisa ler id na sequencia
                                lookbehind = atual;
                                atual = pilha.pop();
                                if(atual.getTipo().toString().equals("identificador")) //leu o ID, beleza, agora vai pra declaracoes
                                {                            
                                    estados.push(new Estados("<declaracoes>", atual.getLinha()));
                                    lookbehind = atual;
                                    atual = pilha.pop();
                                    while(estados.peek().getEstado().equals("<declaracoes>"))
                                    {
                                        //ta em declaracao, apops ter lido um ID, tem se duas opcoes:  ; e ,                                     
                                        if(atual.getLexema().toString().equals(","))
                                        {
                                            lookbehind = atual;
                                            atual = pilha.pop();
                                            if(atual.getTipo().toString().equals("identificador"))
                                            {
                                                lookbehind = atual;
                                                atual = pilha.pop();
                                                //leu virgula e ID. agora pode ler virgula ou ponto e virgula de novo
                                                //atualiza a entrada, mas continua no mesmo estado
                                            }
                                            else
                                            {
                                                if(!((atual.getLexema().equals("INTEIRO")) || (atual.getLexema().equals("REAL")) || (atual.getLexema().equals("BOOLEANO")) || (atual.getLexema().equals("STRING"))))
                                                {
                                                    retorno.add("Erro! esperado: identificador após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());                                                                                                                  
                                                    lookbehind = atual;
                                                    atual = pilha.pop();
                                                }
                                                else
                                                {
                                                    retorno.add("Erro! esperado: identificador após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());                                                                                                                  
                                                }
                                                estados.pop();
                                            }
                                        }
                                        else
                                        {
                                            if(atual.getLexema().toString().equals(";"))
                                            {
                                                lookbehind = atual;
                                                atual = pilha.pop();
                                                estados.pop();
                                            }
                                            else
                                            {
                                                if(!((atual.getLexema().equals("INTEIRO")) || (atual.getLexema().equals("REAL")) || (atual.getLexema().equals("BOOLEANO")) || (atual.getLexema().equals("STRING"))))
                                                {                                            
                                                    retorno.add("Erro! esperados: \",\" ou \";\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());                                                                                                                  
                                                    lookbehind = atual;
                                                    atual = pilha.pop();
                                                }
                                                else
                                                {    
                                                    retorno.add("Erro! esperados: \",\" ou \";\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());                                                                                                                                                                      
                                                }
                                                estados.pop();
                                            } 
                                        }
                                    }
                                }
                                else
                                {
                                    if(!((atual.getLexema().equals("INTEIRO")) || (atual.getLexema().equals("REAL")) || (atual.getLexema().equals("BOOLEANO")) || (atual.getLexema().equals("STRING"))))
                                    {
                                        retorno.add("Erro! esperado: identificador após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());                                                                                                                  
                                        lookbehind = atual;
                                        atual = pilha.pop();
                                    }
                                    else
                                    {
                                        retorno.add("Erro! esperado: identificador após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());
                                    }
                                }
                            }
                            else
                            {                          
                                if(atual.getLexema().equals("PROGRAMA"))
                                {
                                    retorno.add("Erro! esperado: \"{\"  após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());
                                    estados.pop();
                                }
                                else
                                {
                                    retorno.add("Erro! esperados: \"INTEIRO\",  \"REAL\", \"BOOLEANO\", \"STRING\" ou \"}\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());                                                                                                                  
                                    lookbehind = atual;
                                    atual = pilha.pop();      
                                }
                            }
                        }
                    }
                    //leu o fecha chaves do bloco de declaracao, agora precisa ler programa, um ID e abre chaves de novo
                    while(flag == true)
                    {
                        flag = false;
                        if(atual.getLexema().toString().equals("PROGRAMA"))
                        {
                            lookbehind = atual;
                            atual = pilha.pop();
                            if(atual.getTipo().toString().equals("identificador"))
                            {
                                lookbehind = atual;
                                atual = pilha.pop();
                                if(atual.getLexema().toString().equals("{")) //pronto, leu tudo, agora vai pra implementaini
                                {
                                    lacos.push("<programa>");
                                    estados.push(new Estados("<implementaini>", atual.getLinha()));//pra sair de implementaini, ou seja o bloco de implementacoes
                                    //                                tem que ser lido o }. mesmo esquema de declaracoes, soh a complexidade maior XD
                                    lookbehind = atual;
                                    atual = pilha.pop();
                                    while(estados.peek().getEstado().equals("<implementaini>"))//fica dentro desse while todo o rpograma!
                                    {
                                        if(atual.getLexema().toString().equals("}"))//fecha o bloco implementaçao. leu }
                                        { 
                                            estados.pop();
                                            if(pilha.isEmpty())
                                            {
                                                //estados.pop();//avanca a entrada e saai de implementaini    
                                                while(!estados.peek().getEstado().equals("<programa>"))
                                                {       
                                                    //adaptar para if for e whiles tbm
                                                    retorno.add("Erro! esperado: \"}\" para fechar \"{\" na linha "+estados.peek().getLinha()); //sobrou {
                                                    estados.pop();
                                                    while(!lacos.peek().toString().equals("<programa>"))
                                                    {
                                                        retorno.add("Erro! esperado: \"}\" para fechar \"{\" na linha "+estados.peek().getLinha()); //sobrou {
                                                        lacos.pop();
                                                    }
                                                }
                                                estados.pop();
                                                estados.push(new Estados("push push", 0)); //fim do programa
                                                break;
                                            } 
//                                            else
//                                            {
//                                                if(!estados.peek().getEstado().toString().equals("<implementaini>"))
//                                                {
//                                                    System.out.println("Erro! esperado: \"}\" para fechar \"{\" na linha "+estados.peek().getLinha());
//                                                    estados.push(new Estados("<implementaini>", atual.getLinha()));
//                                                    }
//                                            }
                                            lookbehind = atual;
                                            atual = pilha.pop();
                                            if(atual.getLexema().toString().equals("ELSE"))
                                            {
                                                lookbehind = atual;
                                                atual = pilha.pop();
                                                if(atual.getLexema().toString().equals("{"))
                                                {                                                    
                                                    if(lacos.peek().equals("IF"))
                                                    {
                                                        estados.push(new Estados("<implementaini>", atual.getLinha()));   
                                                        lacos.pop();
                                                    }
                                                    else
                                                    {
                                                        retorno.add("Erro! ELSE sem IF correspondente na linha "+atual.getLexema());
                                                    }
                                                    lookbehind = atual;
                                                    atual = pilha.pop();
                                                }
                                                else
                                                {
                                                    retorno.add("Erro! esperado: \"{\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());
                                                    while(atual.getLinha() == pilha.peek().getLinha())
                                                    {
                                                        atual = pilha.pop();
                                                    }
                                                    lookbehind = atual;
                                                    atual = pilha.pop();
//                                                        estados.push(new Estados("<implementaini>", atual.getLinha()));
                                                }
                                            }
//                                            else
//                                            {
//                                                    retorno.add("Erro! esperado: \"ELSE\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());
//                                                    while(atual.getLinha() == pilha.peek().getLinha())
//                                                    {
//                                                        atual = pilha.pop();
//                                                    }
//                                                    lookbehind = atual;
//                                                    atual = pilha.pop();
//                                                    estados.push("<implementaini>");
//                                                }
//                                            }
                                        }
                                        else//se nao quer dizer que tem implementacoes
                                        {
                                            estados.push(new Estados("<implementacoes>", atual.getLinha()));
                                            while(estados.peek().getEstado().equals("<implementacoes>"))
                                            {
                                                if(atual.getTipo().equals("identificador"))// se ta em implementaini e ler ID, vai pra acir
                                                {
                                                    estados.push(new Estados("<acir>", atual.getLinha()));
                                                    lookbehind = atual;
                                                    atual = pilha.pop();//consome... 
                                                    while(estados.peek().getEstado().equals("<acir>"))
                                                    {
//                                                        token não existe!
                                                        if(atual.getLexema().toString().equals("=") )//em acir, le = espra ID ou digito (oculto da BNF #gambi
                                                        {
                                                            lookbehind = atual;
                                                            atual = pilha.pop();
                                                            if((atual.getTipo().toString().equals("identificador")) || (atual.getTipo().toString().equals("digito")))
                                                            {
                                                                estados.push(new Estados("<atribuicao>", atual.getLinha()));
                                                                lookbehind = atual;
                                                                atual = pilha.pop();                                                
                                                                while(estados.peek().getEstado().toString().equals("<atribuicao>"))//belesma, pde encerrar as atribuicoes ou continuar
                                                                {
                                                                    if(atual.getLexema().toString().equals(";"))//leu o ponto e virgula, vai encerrar
                                                                    {
                                                                        estados.pop();//<atribuicao>
                                                                        estados.pop();//<acir>
                                                                        estados.pop();//<implementacoes>, ta em <implementaini> denovo
                                                                        lookbehind = atual;
                                                                        atual = pilha.pop(); //consome...
                                                                    }
                                                                    else//senao aquele id  eh o nome de uma rotina, abrindo parenteses agora
                                                                    {   //precisa ler um operador aritmetico. conjunto oparit contem o lexema atual?
                                                                        if(oprArit.contains(atual.getLexema().toString()))
                                                                        {
                                                                            lookbehind = atual;
                                                                            atual = pilha.pop();
                                                                            if((atual.getTipo().toString().equals("identificador")) || (atual.getTipo().toString().equals("digito")))
                                                                            {
                                                                                //estava em atibuicao apos um id, leu uma operador e outro id. continua em atribuicao
                                                                                lookbehind = atual;
                                                                                atual = pilha.pop();
                                                                            }
                                                                            else
                                                                            {
                                                                                retorno.add("Erro! esperados: \"Identificador\", ou \"dígito\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());
                                                                                while(atual.getLinha() == pilha.peek().getLinha())
                                                                                {
                                                                                    atual = pilha.pop();
                                                                                }
                                                                                lookbehind = atual;
                                                                                atual = pilha.pop();
                                                                                estados.pop();
                                                                                estados.pop();
                                                                                estados.pop();
                                                                            }
                                                                        }
                                                                        else
                                                                        {
                                                                            retorno.add("Erro! esperados: \"operador aritmético\", ou \";\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());
                                                                            while(atual.getLinha() == pilha.peek().getLinha())
                                                                            {
                                                                                atual = pilha.pop();
                                                                            }
                                                                            lookbehind = atual;
                                                                            atual = pilha.pop();
                                                                            estados.pop();
                                                                            estados.pop();
                                                                            estados.pop();
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            else
                                                            {
                                                                retorno.add("Erro! esperado: \"Identificador\" ou \"Digito\" após"+lookbehind.getLexema()+" na linha"+lookbehind.getLinha());
                                                                while(atual.getLinha() == pilha.peek().getLinha())
                                                                {
                                                                    atual = pilha.pop();
                                                                }
                                                                lookbehind = atual;
                                                                atual = pilha.pop();
                                                                estados.pop();
                                                                estados.pop();
                                                            }
                                                        }
                                                        else
                                                        {
                                                            if(atual.getLexema().toString().equals("("))//ta em <acir>, mas vai chamar abertura de rotina e ir pro estado rot
                                                            {
                                                                lookbehind = atual;
                                                                atual = pilha.pop();
                                                                if(atual.getLexema().toString().equals(")"))//cadeia obrigatoria ();
                                                                {
                                                                    lookbehind = atual;
                                                                    atual = pilha.pop();
                                                                    if(atual.getLexema().toString().equals(";"))
                                                                    {
                                                                        lookbehind = atual;
                                                                        atual = pilha.pop();//consome
                                                                        estados.pop();//sai de <acir> pra <implementacoes>
                                                                        estados.pop();//<implementaini>
                                                                        //terminou a chamada de rotina, volta pra <implementaini>
                                                                    }
                                                                    else
                                                                    {
                                                                        retorno.add("Erro! esperado: \";\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());
                                                                        while(atual.getLinha() == pilha.peek().getLinha())
                                                                        {
                                                                            atual = pilha.pop();
                                                                        }
                                                                        lookbehind = atual;
                                                                        atual = pilha.pop();
                                                                        estados.pop();
                                                                        estados.pop();
                                                                    }
                                                                }
                                                                else
                                                                {
                                                                    retorno.add("Erro! esperado: \")\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());
                                                                    while(atual.getLinha() == pilha.peek().getLinha())
                                                                    {
                                                                        atual = pilha.pop();
                                                                    }
                                                                    lookbehind = atual;
                                                                    atual = pilha.pop();
                                                                    estados.pop();
                                                                    estados.pop();
                                                                }
                                                            }
                                                            else
                                                            {
                                                                retorno.add("Erro! esperados: \"(\" ou \"=\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());
                                                                while(atual.getLinha() == pilha.peek().getLinha())
                                                                {
                                                                    atual = pilha.pop();
                                                                }
                                                                lookbehind = atual;
                                                                atual = pilha.pop();
                                                                estados.pop();
                                                                estados.pop();
                                                            }
                                                        }
                                                    }
                                                }
                                                else
                                                {
                                                    if(atual.getLexema().toString().equals("IF"))// vai de implementacao pra condicional
                                                    {
                                                        estados.push(new Estados("<condicional>", atual.getLinha()));
                                                        lookbehind = atual;
                                                        atual = pilha.pop();
                                                        if(atual.getLexema().toString().equals("("))//vai ler IF ( ID OPRLOG ID ) { <implementa>
                                                        {
                                                            lookbehind = atual;
                                                            atual = pilha.pop();
                                                            if(atual.getTipo().toString().equals("identificador"))
                                                            {
                                                                lookbehind = atual;
                                                                atual = pilha.pop();
                                                                if(oprLog.contains(atual.getLexema().toString()))
                                                                {
                                                                    lookbehind = atual;
                                                                    atual = pilha.pop();
                                                                    if((atual.getTipo().toString().equals("identificador")) || (atual.getTipo().toString().equals("digito")))
                                                                    {
                                                                        lookbehind = atual;
                                                                        atual = pilha.pop();
                                                                        if(atual.getLexema().toString().equals(")"))
                                                                        {
                                                                            lookbehind = atual;
                                                                            atual = pilha.pop();
                                                                            if(atual.getLexema().toString().equals("{"))
                                                                            {                                                                              
                                                                                lookbehind = atual;
                                                                                atual = pilha.pop();                          //belesma, entrou no for interno e agora o que faz?
                                                                                //vai pro estado implementaini, náo volta, empilha outro, e le a proxima entrada como\
                                                                                //se fosse o primeiro implementaini
                                                                                estados.pop();
                                                                                estados.pop();
                                                                                estados.push(new Estados("<implementaini>", atual.getLinha()));//ciclo interno do for, implementaini       
                                                                                lacos.push("IF");
                                                                            }
                                                                            else
                                                                            {
                                                                                retorno.add("Erro! esperado: \"{\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());
                                                                                while(atual.getLinha() == pilha.peek().getLinha())
                                                                                {
                                                                                    atual = pilha.pop();
                                                                                }
                                                                                lookbehind = atual;
                                                                                atual = pilha.pop();
                                                                                estados.pop();
                                                                                estados.pop();
                                                                            }
                                                                        }
                                                                        else
                                                                        {
                                                                            retorno.add("Erro! esperado: \")\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());
                                                                            while(atual.getLinha() == pilha.peek().getLinha())
                                                                            {
                                                                                atual = pilha.pop();
                                                                            }
                                                                            lookbehind = atual;
                                                                            atual = pilha.pop();
                                                                            estados.pop();
                                                                            estados.pop();
                                                                        }
                                                                    }
                                                                    else
                                                                    {
                                                                        retorno.add("Erro! esperados: \"Identificador\" ou \"Digito\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());
                                                                        while(atual.getLinha() == pilha.peek().getLinha())
                                                                        {
                                                                            atual = pilha.pop();
                                                                        }
                                                                        lookbehind = atual;
                                                                        atual = pilha.pop();
                                                                        estados.pop();
                                                                        estados.pop();
                                                                        //estados.push("<implementaini>");
                                                                    }
                                                                }
                                                                else
                                                                {
                                                                    retorno.add("Erro! esperado: \"Operador Lógico\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());
                                                                    while(atual.getLinha() == pilha.peek().getLinha())
                                                                    {
                                                                        atual = pilha.pop();
                                                                    }
                                                                    lookbehind = atual;
                                                                    atual = pilha.pop();
                                                                    estados.pop();
                                                                    estados.pop();
                                                                }
                                                            }
                                                            else
                                                            {
                                                                retorno.add("Erro! esperado: \"Identificador\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());
                                                                while(atual.getLinha() == pilha.peek().getLinha())
                                                                {
                                                                    atual = pilha.pop();
                                                                }
                                                                lookbehind = atual;
                                                                atual = pilha.pop();
                                                                estados.pop();
                                                                estados.pop();
                                                            }
                                                        }
                                                        else
                                                        {
                                                            retorno.add("Erro! esperado: \"(\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());
                                                            while(atual.getLinha() == pilha.peek().getLinha())
                                                            {
                                                                atual = pilha.pop();
                                                            }
                                                            lookbehind = atual;
                                                            atual = pilha.pop();
                                                            estados.pop();
                                                            estados.pop();
                                                        }
                                                    }
                                                    else //o proximo if eh de laco, duas cadeias diferentes se ler for ou while, empilha laco e deriva
                                                        // E CONTINUA DERIVANDO AS CADEIAS
                                                    {
                                                        if(atual.getLexema().toString().equals("FOR"))// vai de implementacao pra condicional
                                                        {
                                                            estados.push(new Estados("<lacos>", atual.getLinha()));
                                                            lookbehind = atual;
                                                            atual = pilha.pop();
                                                            if(atual.getLexema().toString().equals("("))
                                                            {
                                                                lookbehind = atual;
                                                                atual  = pilha.pop();
                                                                if(atual.getTipo().toString().equals("identificador"))
                                                                {
                                                                    lookbehind = atual;
                                                                    atual = pilha.pop();
                                                                    if(atual.getLexema().toString().equals("="))
                                                                    {
                                                                        lookbehind = atual;
                                                                        atual = pilha.pop();
                                                                        if( (atual.getTipo().toString().equals("identificador")) || (atual.getTipo().toString().equals("digito")) )
                                                                        {
                                                                            lookbehind = atual;
                                                                            atual = pilha.pop();
                                                                            if(atual.getLexema().toString().equals(";"))
                                                                            {
                                                                                lookbehind = atual;
                                                                                atual = pilha.pop();
                                                                                if(atual.getTipo().toString().equals("identificador"))
                                                                                {
                                                                                    lookbehind = atual;
                                                                                    atual = pilha.pop();
                                                                                    if(oprLog.contains(atual.getLexema().toString()))
                                                                                    {
                                                                                        lookbehind = atual;
                                                                                        atual = pilha.pop();
                                                                                        if( (atual.getTipo().toString().equals("identificador")) || (atual.getTipo().toString().equals("digito")))
                                                                                        {
                                                                                            lookbehind = atual;
                                                                                            atual = pilha.pop();
                                                                                            if(atual.getLexema().toString().equals(";"))
                                                                                            {
                                                                                                lookbehind = atual;
                                                                                                atual = pilha.pop();
                                                                                                if( (atual.getTipo().toString().equals("identificador")) || (atual.getTipo().toString().equals("digito")))
                                                                                                {
                                                                                                    lookbehind = atual;
                                                                                                    atual = pilha.pop();
                                                                                                    if(atual.getLexema().toString().equals(")"))
                                                                                                    {
                                                                                                        lookbehind = atual;
                                                                                                        atual = pilha.pop();
                                                                                                        if(atual.getLexema().toString().equals("{"))
                                                                                                        {
                                                                                                            lookbehind = atual;
                                                                                                            atual = pilha.pop();
                                                                                                            estados.pop();
                                                                                                            estados.pop();
                                                                                                           // estados.push("<els>");
                                                                                                            estados.push(new Estados("<implementaini>", atual.getLinha()));                                                                                            
                                                                                                        }
                                                                                                        else
                                                                                                        {
                                                                                                            retorno.add("Erro! esperado: \"{\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());
                                                                                                            while(atual.getLinha() == pilha.peek().getLinha())
                                                                                                            {
                                                                                                                atual = pilha.pop();
                                                                                                            }
                                                                                                            lookbehind = atual;
                                                                                                            atual = pilha.pop();
                                                                                                            estados.pop();
                                                                                                            estados.pop();
                                                                                                        }
                                                                                                    } 
                                                                                                    else
                                                                                                    {
                                                                                                        retorno.add("Erro! esperado: \")\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());
                                                                                                        while(atual.getLinha() == pilha.peek().getLinha())
                                                                                                        {
                                                                                                            atual = pilha.pop();
                                                                                                        }
                                                                                                        lookbehind = atual;
                                                                                                        atual = pilha.pop();
                                                                                                        estados.pop();
                                                                                                        estados.pop();
                                                                                                    }
                                                                                                }
                                                                                                else
                                                                                                {
                                                                                                    retorno.add("Erro! esperado: \"Identificador\" ou \"Dígito\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());
                                                                                                    while(atual.getLinha() == pilha.peek().getLinha())
                                                                                                    {
                                                                                                        atual = pilha.pop();
                                                                                                    }
                                                                                                    lookbehind = atual;
                                                                                                    atual = pilha.pop();
                                                                                                    estados.pop();
                                                                                                    estados.pop();
                                                                                                }
                                                                                            }
                                                                                            else
                                                                                            {
                                                                                                retorno.add("Erro! esperado: \";\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());
                                                                                                while(atual.getLinha() == pilha.peek().getLinha())
                                                                                                {
                                                                                                    atual = pilha.pop();
                                                                                                }
                                                                                                lookbehind = atual;
                                                                                                atual = pilha.pop();
                                                                                                estados.pop();
                                                                                                estados.pop();
                                                                                            }
                                                                                        }
                                                                                        else
                                                                                        {
                                                                                            retorno.add("Erro! esperados: \"Identificador\" ou \"Dígito\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());
                                                                                            while(atual.getLinha() == pilha.peek().getLinha())
                                                                                            {
                                                                                                atual = pilha.pop();
                                                                                            }
                                                                                            lookbehind = atual;
                                                                                            atual = pilha.pop();
                                                                                            estados.pop();
                                                                                            estados.pop();
                                                                                        }
                                                                                    }
                                                                                    else
                                                                                    {
                                                                                        retorno.add("Erro! esperado: \"Operador Lógico\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());
                                                                                        while(atual.getLinha() == pilha.peek().getLinha())
                                                                                        {
                                                                                            atual = pilha.pop();
                                                                                        }
                                                                                        lookbehind = atual;
                                                                                        atual = pilha.pop();
                                                                                        estados.pop();
                                                                                        estados.pop();
                                                                                    }
                                                                                }
                                                                                else
                                                                                {
                                                                                    retorno.add("Erro! esperado: \"Identificador\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());
                                                                                    while(atual.getLinha() == pilha.peek().getLinha())
                                                                                    {
                                                                                        atual = pilha.pop();
                                                                                    }
                                                                                    lookbehind = atual;
                                                                                    atual = pilha.pop();
                                                                                    estados.pop();
                                                                                    estados.pop();
                                                                                }
                                                                            }
                                                                            else
                                                                            {
                                                                                retorno.add("Erro! esperado: \";\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());
                                                                                while(atual.getLinha() == pilha.peek().getLinha())
                                                                                {
                                                                                    atual = pilha.pop();
                                                                                }
                                                                                lookbehind = atual;
                                                                                atual = pilha.pop();
                                                                                estados.pop();
                                                                                estados.pop();
                                                                            }
                                                                        }
                                                                        else
                                                                        {
                                                                            retorno.add("Erro! esperados: \"Identificador\" ou \"Dígito\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());
                                                                            while(atual.getLinha() == pilha.peek().getLinha())
                                                                            {
                                                                                atual = pilha.pop();
                                                                            }
                                                                            lookbehind = atual;
                                                                            atual = pilha.pop();
                                                                            estados.pop();
                                                                            estados.pop();
                                                                        }
                                                                    }
                                                                    else
                                                                    {
                                                                        retorno.add("Erro! esperado: \"=\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());
                                                                        while(atual.getLinha() == pilha.peek().getLinha())
                                                                        {
                                                                            atual = pilha.pop();
                                                                        }
                                                                        lookbehind = atual;
                                                                        atual = pilha.pop();
                                                                        estados.pop();
                                                                        estados.pop();
                                                                    }
                                                                }
                                                                else
                                                                {
                                                                    retorno.add("Erro! esperado: \"Identificador\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());
                                                                    while(atual.getLinha() == pilha.peek().getLinha())
                                                                    {
                                                                        atual = pilha.pop();
                                                                    }
                                                                    lookbehind = atual;
                                                                    atual = pilha.pop();
                                                                    estados.pop();
                                                                    estados.pop();
                                                                }
                                                            }
                                                            else
                                                            {
                                                                retorno.add("Erro! esperado: \"(\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());
                                                                while(atual.getLinha() == pilha.peek().getLinha())
                                                                {
                                                                    atual = pilha.pop();
                                                                }
                                                                lookbehind = atual;
                                                                atual = pilha.pop();
                                                                estados.pop();
                                                                estados.pop();
                                                            }
                                                        }
                                                        //end FOR
                                                        else
                                                        {
                                                            if(atual.getLexema().toString().equals("WHILE"))
                                                            {
                                                                estados.push(new Estados("<lacos>", atual.getLinha()));
                                                                lookbehind = atual;
                                                                atual = pilha.pop();
                                                                if(atual.getLexema().toString().equals("("))
                                                                {
                                                                    lookbehind = atual;
                                                                    atual = pilha.pop();
                                                                    if(atual.getTipo().toString().equals("identificador"))
                                                                    {
                                                                        lookbehind = atual;
                                                                        atual = pilha.pop();
                                                                        if(oprLog.contains(atual.getLexema().toString()))
                                                                        {
                                                                            lookbehind = atual;
                                                                            atual = pilha.pop();
                                                                            if( (atual.getTipo().toString().equals("identificador")) || atual.getTipo().toString().equals("digito"))
                                                                            {
                                                                                lookbehind = atual;
                                                                                atual = pilha.pop();
                                                                                if(atual.getLexema().toString().equals(")"))
                                                                                {
                                                                                    lookbehind = atual;
                                                                                    atual = pilha.pop();
                                                                                    if(atual.getLexema().toString().equals("{"))
                                                                                    {
                                                                                        lookbehind = atual;
                                                                                        atual = pilha.pop();
                                                                                        estados.pop();
                                                                                        estados.pop();
                                                                                        estados.push(new Estados("<implementaini>", atual.getLinha()));                                                                                                                                                         
                                                                                    }                                                                    
                                                                                    else
                                                                                    {
                                                                                        retorno.add("Erro! esperado: \"{\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());
                                                                                        while(atual.getLinha() == pilha.peek().getLinha())
                                                                                        {
                                                                                            atual = pilha.pop();
                                                                                        }
                                                                                        lookbehind = atual;
                                                                                        atual = pilha.pop();
                                                                                        estados.pop();
                                                                                        estados.pop();
                                                                                    }
                                                                                }
                                                                                else{
                                                                                    retorno.add("Erro! esperado: \")\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());
                                                                                    lookbehind = atual;
                                                                                    atual = pilha.pop();
                                                                                    estados.pop();
                                                                                    estados.pop();
                                                                                    
                                                                                }
                                                                            }
                                                                            else
                                                                            {
                                                                                retorno.add("Erro! esperados: \"Identificador\" ou \"Dígito\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());
                                                                                while(atual.getLinha() == pilha.peek().getLinha())
                                                                                {
                                                                                    atual = pilha.pop();
                                                                                }
                                                                                lookbehind = atual;
                                                                                atual = pilha.pop();
                                                                                estados.pop();
                                                                                estados.pop();
                                                                            }
                                                                        }
                                                                        else
                                                                        {
                                                                            retorno.add("Erro! esperado: \"Operador Lógico\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());
                                                                            while(atual.getLinha() == pilha.peek().getLinha())
                                                                            {
                                                                                atual = pilha.pop();
                                                                            }
                                                                            lookbehind = atual;
                                                                            atual = pilha.pop();
                                                                            estados.pop();
                                                                            estados.pop();
                                                                        }
                                                                    }
                                                                    else
                                                                    {
                                                                        retorno.add("Erro! esperado: \"Identificador\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());
                                                                        while(atual.getLinha() == pilha.peek().getLinha())
                                                                        {
                                                                            atual = pilha.pop();
                                                                        }
                                                                        lookbehind = atual;
                                                                        atual = pilha.pop();
                                                                        estados.pop();
                                                                        estados.pop();
                                                                    }
                                                                } 
                                                                else
                                                                {
                                                                    retorno.add("Erro! esperado: \"(\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());
                                                                    while(atual.getLinha() == pilha.peek().getLinha())
                                                                    {
                                                                        atual = pilha.pop();
                                                                    }
                                                                    lookbehind = atual;
                                                                    atual = pilha.pop();
                                                                    estados.pop();
                                                                    estados.pop();
                                                                }
                                                            }//end WHILE acabou laco e vai pra inandout
                                                            else
                                                            {                                                
                                                                if(atual.getLexema().toString().equals("ENTRA"))
                                                                {
                                                                    lookbehind = atual;
                                                                    atual = pilha.pop();
                                                                    estados.push(new Estados("<inandout>", atual.getLinha()));
                                                                    if(atual.getLexema().toString().equals("("))
                                                                    {
                                                                        lookbehind = atual;
                                                                        atual = pilha.pop();
                                                                        if(atual.getTipo().toString().equals("identificador"))
                                                                        {                                                                            
                                                                            lookbehind = atual;
                                                                            atual = pilha.pop();
                                                                            if(atual.getLexema().toString().equals(")"))
                                                                            {
                                                                                lookbehind = atual;
                                                                                atual = pilha.pop();
                                                                                if(atual.getLexema().toString().equals(";"))
                                                                                {
                                                                                    lookbehind = atual;
                                                                                    atual = pilha.pop();
                                                                                    estados.pop();
                                                                                    estados.pop();
                                                                                }      
                                                                                else
                                                                                {
                                                                                    retorno.add("Erro! esperado: \";\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());
                                                                                    while(atual.getLinha() == pilha.peek().getLinha())
                                                                                    {                                                                                 
                                                                                        atual = pilha.pop();
                                                                                    }
                                                                                    lookbehind = atual;
                                                                                    atual = pilha.pop();
                                                                                    estados.pop();
                                                                                    estados.pop();
                                                                                }
                                                                            }
                                                                            else
                                                                            {
                                                                                retorno.add("Erro! esperado: \")\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());
                                                                                while(atual.getLinha() == pilha.peek().getLinha())
                                                                                {
                                                                                    atual = pilha.pop();
                                                                                }
                                                                                lookbehind = atual;
                                                                                atual = pilha.pop();
                                                                                estados.pop();
                                                                                estados.pop();
                                                                            }                                                                           
                                                                        }
                                                                        else
                                                                        {
                                                                            retorno.add("Erro! esperado: \"Identificador\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());
                                                                            while(atual.getLinha() == pilha.peek().getLinha())
                                                                            {
                                                                                atual = pilha.pop();
                                                                            }
                                                                            lookbehind = atual;
                                                                            atual = pilha.pop();
                                                                            estados.pop();
                                                                            estados.pop();
                                                                        }
                                                                    }
                                                                    else
                                                                    {
                                                                        retorno.add("Erro! esperado: \"(\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());
                                                                        while(atual.getLinha() == pilha.peek().getLinha())
                                                                        {
                                                                            atual = pilha.pop();
                                                                        }
                                                                        lookbehind = atual;
                                                                        atual = pilha.pop();
                                                                        estados.pop();
                                                                        estados.pop();
                                                                    }
                                                                }
                                                                else
                                                                {
                                                                    if(atual.getLexema().toString().equals("SAI"))
                                                                    {
                                                                        lookbehind = atual;
                                                                        atual = pilha.pop();
                                                                        estados.push(new Estados("<inandout>", atual.getLinha()));
                                                                        if(atual.getLexema().toString().equals("("))
                                                                        {
                                                                            lookbehind = atual;
                                                                            atual = pilha.pop();
                                                                            estados.push(new Estados("<saida>", atual.getLinha()));                                                                     
                                                                            while(estados.peek().getEstado().toString().equals("<saida>"))
                                                                            {                      
                                                                                if(atual.getTipo().toString().equals("identificador"))
                                                                                {
                                                                                    lookbehind = atual;
                                                                                    atual = pilha.pop();    
                                                                                    estados.push(new Estados("<saidaaux>", atual.getLinha()));
                                                                                    while(estados.peek().getEstado().toString().equals("<saidaaux>"))
                                                                                    {
                                                                                        if(atual.getLexema().toString().equals(","))
                                                                                        {
                                                                                            lookbehind = atual;
                                                                                            atual = pilha.pop();
                                                                                            estados.pop();
                                                                                        }
                                                                                        else
                                                                                        {
                                                                                            if(atual.getLexema().toString().equals(")"))
                                                                                            {
                                                                                                lookbehind = atual;
                                                                                                atual = pilha.pop();
                                                                                                if(atual.getLexema().toString().equals(";"))
                                                                                                {
                                                                                                    lookbehind = atual;
                                                                                                    atual = pilha.pop();
                                                                                                }
                                                                                                else
                                                                                                {
                                                                                                    retorno.add("Erro! esperado: \";\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());
                                                                                                    while(atual.getLinha() == pilha.peek().getLinha())
                                                                                                    {
                                                                                                        atual = pilha.pop();
                                                                                                    }
                                                                                                    lookbehind = atual;
                                                                                                    atual = pilha.pop();                                                                                          
                                                                                                }
                                                                                                estados.pop();
                                                                                                estados.pop();
                                                                                                estados.pop();
                                                                                                estados.pop();
                                                                                            }
                                                                                            else
                                                                                            {
                                                                                                retorno.add("Erro! esperado: \")\" ou \",\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());
                                                                                                while(atual.getLinha() == pilha.peek().getLinha())
                                                                                                {
                                                                                                    atual = pilha.pop();
                                                                                                }
                                                                                                lookbehind = atual;
                                                                                                atual = pilha.pop();
                                                                                                estados.pop();
                                                                                                estados.pop();
                                                                                                estados.pop();
                                                                                                estados.pop();
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                                else
                                                                                {
                                                                                    if(atual.getTipo().toString().equals("txt_string"))
                                                                                    {
                                                                                        lookbehind = atual;
                                                                                        atual = pilha.pop();    
                                                                                        estados.push(new Estados("<saidaaux>", atual.getLinha()));
                                                                                        while(estados.peek().getEstado().toString().equals("<saidaaux>"))
                                                                                        {
                                                                                            if(atual.getLexema().toString().equals(","))
                                                                                            {
                                                                                                lookbehind = atual;
                                                                                                atual = pilha.pop();
                                                                                                estados.pop();
                                                                                            }
                                                                                            else
                                                                                            {   
                                                                                                if(atual.getLexema().toString().equals(")"))
                                                                                                {
                                                                                                    lookbehind = atual;
                                                                                                    atual = pilha.pop();
                                                                                                    if(atual.getLexema().toString().equals(";"))
                                                                                                    {
                                                                                                        estados.pop();
                                                                                                        estados.pop();
                                                                                                        estados.pop();
                                                                                                        estados.pop();
                                                                                                        lookbehind = atual;
                                                                                                        atual = pilha.pop();                                                                                                        
                                                                                                    }
                                                                                                    else
                                                                                                    {
                                                                                                        retorno.add("Erro! esperado: \")\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());                                                                                                    
                                                                                                        while(atual.getLinha() == pilha.peek().getLinha())
                                                                                                        {
                                                                                                            atual = pilha.pop();
                                                                                                        }
                                                                                                        lookbehind = atual;
                                                                                                        atual = pilha.pop();
                                                                                                        estados.pop();
                                                                                                        estados.pop();
                                                                                                        estados.pop();
                                                                                                        estados.pop();
                                                                                                    }
                                                                                                }
                                                                                                else
                                                                                                {
                                                                                                    retorno.add("Erro! esperados: \",\" ou \")\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());
                                                                                                    while(atual.getLinha() == pilha.peek().getLinha())
                                                                                                    {
                                                                                                        atual = pilha.pop();
                                                                                                    }
                                                                                                    lookbehind = atual;
                                                                                                    atual = pilha.pop();
                                                                                                    estados.pop();
                                                                                                    estados.pop();
                                                                                                    estados.pop();
                                                                                                    estados.pop();
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                    else
                                                                                    {
                                                                                        retorno.add("Erro! esperados: \"identificador\" ou \"txt_string\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());
                                                                                        while(atual.getLinha() == pilha.peek().getLinha())
                                                                                        {
                                                                                            atual = pilha.pop();
                                                                                        }
                                                                                        lookbehind = atual;
                                                                                        atual = pilha.pop();
                                                                                        estados.pop();
                                                                                        estados.pop();
                                                                                        estados.pop();
                                                                                    }
                                                                                }
                                                                            }                                                                            
                                                                        }
                                                                        else
                                                                        {
                                                                            retorno.add("Erro! esperado: \"(\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());
                                                                            while(atual.getLinha() == pilha.peek().getLinha())
                                                                            {
                                                                                atual = pilha.pop();
                                                                            }
                                                                            lookbehind = atual;
                                                                            atual = pilha.pop();
                                                                            estados.pop();
                                                                            estados.pop();
                                                                        }//fechou o sai
                                                                    }
                                                                    else
                                                                    {                                                                      
                                                                        if(atual.getLexema().toString().equals("ELSE"))
                                                                        {                                                                            
                                                                            pilha.push(atual);
                                                                            atual.setLexema("}");
                                                                        }
                                                                        else
                                                                        {
                                                                            if(pilha.isEmpty())
                                                                            {
                                                                                //estados.pop();//avanca a entrada e saai de implementaini
                                                                                while(estados.peek() != null)
                                                                                {
                                                                                    System.out.println("Erro! esperado: \"}\" para fechar \"{\" na linha "+estados.peek().getLinha()); //sobrou {
                                                                                    estados.pop();
                                                                                }
                                                                                break; //fim do programa
                                                                            } 
                                                                            else
                                                                            {
                                                                                if(atual.getLexema().toString().equals("ROTINA"))
                                                                                {
                                                                                    while(!lacos.toString().equals("<programa>"))
                                                                                    {
                                                                                        System.out.println("Erro! esperado: \"{\" para abrir \"}\" na linha "+estados.peek().getLinha());
                                                                                        lacos.pop();
                                                                                    }
                                                                                    estados.push(new Estados("<implementaiini>", atual.getLinha()));
                                                                                }
                                                                            }
                                                                            System.out.print("essa porra só reconhece na verssão expresso com açúcar: ");
                                                                            System.out.println(atual.getLexema()+" "+atual.getLinha());
                                                                            try
                                                                            { 
                                                                                atual = pilha.pop();
                                                                            } catch (EmptyStackException ESE) {}
                                                                        }
                                                                        estados.pop();
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
//                                    if(!pilha.empty())
//                                    {                                        
//                                        estados.push("<rotinas>");
//                                        while(estados.peek().equals("<rotinas>"))
//                                        {
//                                            if(atual.getLexema().toString().equals("ROTINA"))
//                                            {
//                                                lookbehind = atual;
//                                                atual = pilha.pop();
//                                                if(atual.getTipo().toString().equals("identificador"))
//                                                {
//                                                    lookbehind = atual;
//                                                    atual = pilha.pop();
//                                                    if(atual.getTipo().toString().equals("("))
//                                                    {
//                                                        lookbehind = atual;
//                                                        atual = pilha.pop();
//                                                        if(atual.getTipo().toString().equals(")"))
//                                                        {
//                                                            lookbehind = atual;
//                                                            atual = pilha.pop();
//                                                            if(atual.getTipo().toString().equals("{"))
//                                                            {
//                                                                lookbehind = atual;
//                                                                atual = pilha.pop();
//                                                            }
//                                                            else
//                                                            {
//                                                                
//                                                            }
//                                                        }
//                                                        else
//                                                        {
//                                                            
//                                                        }
//                                                    }
//                                                    else
//                                                    {
//                                                        
//                                                    }
//                                                }5
//                                                else
//                                                {
//                                                    
//                                                }
//                                            }
//                                            else
//                                            {
//                                                
//                                            }
//                                            System.out.println(atual.getLexema());
//                                        }
//                                    }
//                                }
//                                else
//                                {
//                                    retorno.add("Erro! esperado: \"{\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());
//                                    pilha.push(atual);
//                                    Tokens aux = new Tokens("{", atual.getLinha());
//                                    pilha.push(aux);
//                                    aux = new Tokens("GAMBI", atual.getLinha());
//                                    aux.setTipo("identificador");
//                                    pilha.push(aux);
//                                    aux = new Tokens("PROGRAMA", atual.getLinha());
//                                    pilha.push(aux);
//                                    lookbehind = atual;
//                                    atual = pilha.pop();
//                                    flag = true;
//                                }
                                }
                                else
                                {
                                    retorno.add("Erro! esperado: \"Identificador\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());
                                    if(!atual.getLexema().toString().equals("PROGRAMA"))
                                    {                                    
                                        if(pilha.peek().getLexema().equals("{"))
                                        {
                                            atual.setLexema("GAMBI");
                                            atual.setTipo("identificador");
                                            pilha.push(atual);
                                            Tokens aux = new Tokens("PROGRAMA", atual.getLinha());
                                            aux.setTipo("palavra_reservada");
                                            pilha.push(aux);                             
                                        }
                                        else
                                        {
                                            while(atual.getLinha() == pilha.peek().getLinha())
                                            {
                                                atual = pilha.pop();
                                            }
                                        }
                                        lookbehind = atual;
                                        atual = pilha.pop(); 
                                        flag = true; 
                                    }
                                    else
                                    {
                                        lookbehind = atual;
                                        atual = pilha.pop(); 
                                        flag = true;   
                                    }                                
                                }
                            }
                            else
                            {                            
                                retorno.add("Erro! esperado: \"PROGRAMA\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());
                                lookbehind = atual;
                                atual = pilha.pop();
                            }
                        }
                    }
                }
                else
                {
                    if(estados.size() > 1)
                    {
                        estados.pop();
                        estados.push(new Estados("<implementaini>", atual.getLinha()));
                    }
                    else
                    {
                        if(atual.getLexema().toString().equals("ROTINA"))
                        {
                            lookbehind = atual;
                            atual = pilha.pop();                        
                            if(atual.getTipo().toString().equals("identificador"))
                            {
                                lookbehind = atual;
                                atual = pilha.pop();
                                if(atual.getLexema().toString().equals("("))
                                {
                                    lookbehind = atual;
                                    atual = pilha.pop();
                                    if(atual.getLexema().toString().equals(")"))
                                    {
                                        lookbehind = atual;
                                        atual = pilha.pop();
                                        if(atual.getLexema().toString().equals("{"))
                                        {
                                            lookbehind = atual;
                                            atual = pilha.pop();
                                            estados.push(new Estados("<implementaini>", atual.getLinha()));
                                        }
                                        else
                                        {
                                            retorno.add("Erro! esperado: \")\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());                                                                                                    
                                            while(atual.getLinha() == pilha.peek().getLinha())
                                            {
                                                atual = pilha.pop();
                                            }
                                            lookbehind = atual;
                                            atual = pilha.pop();
                                        }
                                    }
                                    else
                                    {
                                        retorno.add("Erro! esperado: \")\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());                                                                                                    
                                        while(atual.getLinha() == pilha.peek().getLinha())
                                        {
                                            atual = pilha.pop();
                                        }
                                        lookbehind = atual;
                                        atual = pilha.pop();
                                    }
                                }
                                else
                                {
                                    retorno.add("Erro! esperado: \"(\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());                                                                                                    
                                    while(atual.getLinha() == pilha.peek().getLinha())
                                    {
                                        atual = pilha.pop();
                                    }
                                    lookbehind = atual;
                                    atual = pilha.pop();

                                }
                            }
                            else
                            {
                                retorno.add("Erro! esperado: \"identificador\" após "+lookbehind.getLexema()+" na linha "+lookbehind.getLinha());                                                                                                    
                                while(atual.getLinha() == pilha.peek().getLinha())
                                {
                                    atual = pilha.pop();
                                }
                                lookbehind = atual;
                                atual = pilha.pop();
                            }
                        }
                        else
                        {    
                            try
                            {               
                                retorno.add("Erro! esperado: \"{\" correspondente ao \"}\""+" na linha "+atual.getLinha()); //sobrou {             
                                while(pilha.peek() != null)
                                {
                                    if(atual.getLexema().toString().equals("}"))
                                    {
                                        retorno.add("Erro! esperado: \"{\" correspondente ao \"}\""+" na linha "+atual.getLinha()); //sobrou {
                                        atual = pilha.pop();
                                    }
                                    else
                                    {
                                        atual = pilha.pop();
                                    }
                                }
                            } catch (EmptyStackException ESE) {}
                            break;
                        }
                    }
                }
            }// while do programa
        }
        else
        {
            retorno.add("Erro! esperado: \"VARIAVEIS\" no início do procedimento");
        }        
        return retorno;
    }

    public static String destrincha(LinkedList<String> vai) {
        String retorno = new String();
        for(int i=0;i<vai.size();i++){
            retorno += vai.get(i)+"\n";
        }
        return retorno;
    }
}
